package com.electronic.utils.pdf;


import com.itextpdf.text.pdf.parser.ImageRenderInfo;
import com.itextpdf.text.pdf.parser.RenderListener;
import com.itextpdf.text.pdf.parser.TextRenderInfo;
import lombok.Getter;
import lombok.Setter;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @Author: IFCA
 * @Description: pdf文件解析的监听器，用来监听对pdf文件的解析过程，并获得关键字坐标
 */
public class PdfRenderListener implements RenderListener {

    /**
     * 标示是否提取到了关键字坐标值
     */
    @Setter
    private boolean hasCompleted = false;
    /**
     * 待解析的关键字
     */
    @Setter
    @Getter
    private String keyWord = null;
    /**
     * 关键字的文本渲染信息
     */
    @Setter
    @Getter
    private List<TextRenderInfo> textRender = new CopyOnWriteArrayList<>();

    /**
     * pdf文件解析时得到的数据
     */
    @Setter
    @Getter
    private StringBuffer pdfStr = new StringBuffer();
    /**
     * 是否追加解析pdf内容
     */
    private boolean isAppend = true;

    /**
     * 负责分析解析pdf文件时得到的数据从而找到关键字的坐标值
     */
    @Override
    public void renderText(com.itextpdf.text.pdf.parser.TextRenderInfo renderInfo) {
        // 拼接保存解析到pdf内容
        if (isAppend) {
            // 由于存在解析出的内容，关键字换行的情况，所以将已解析到的内容全部缓存
            pdfStr.append(renderInfo.getText());
        }

        // 通过对比解析的文本是否包含关键字来得到文本渲染的信息
        int q = pdfStr.indexOf(keyWord);
        while (q != -1) {
            StringBuffer tempKeyword = new StringBuffer();
            List<TextRenderInfo> textRenderInfoList = renderInfo.getCharacterRenderInfos();
            for (TextRenderInfo textRenderInfo : textRenderInfoList) {
                tempKeyword.append(textRenderInfo.getText());
                if (tempKeyword.indexOf(keyWord) != -1) {
                    textRender.add(textRenderInfo);
                    // 已完成解析
                    hasCompleted = true;
                    tempKeyword.setLength(0);
                } else {
                    char[] chars = keyWord.toCharArray();
                    char[] chars1 = tempKeyword.toString().toCharArray();
                    if (chars.length > 0 && chars1.length > 0) {
                        boolean isTrue = chars1[chars1.length - 1] == chars[chars.length - 1];
                        if (isTrue) {
                            char[] charsTemp = new char[chars.length];
                            int charsTempInt = charsTemp.length - 1;
                            // 判断是否完全匹配关键字
                            if (chars1.length > charsTemp.length) {
                                for (int m = chars1.length-1,p = 0; m > p; m--) {
                                    charsTemp[charsTempInt] = chars1[m];
                                    charsTempInt = charsTempInt - 1;
                                    if (charsTempInt < 0) {
                                        break;
                                    }
                                }
                                if (Arrays.equals(chars, charsTemp)) {
                                    textRender.add(textRenderInfo);
                                }
                            } else {
                                int charsLength = chars1.length - 1;
                                boolean isExists = false;
                                for (int m = chars.length-1,p = 0; m > p; m--) {
                                    if (chars[m] == chars1[charsLength]) {
                                        isExists = true;
                                    }
                                    charsLength = charsLength - 1;
                                    if (charsLength < 0) {
                                        break;
                                    }
                                }
                                if (isExists) {
                                    textRender.add(textRenderInfo);
                                }
                            }

                            // 已完成解析
                            hasCompleted = true;
                            tempKeyword.setLength(0);
                        }
                    }
                }
            }
            // 取坐标时，按字符取如果关键字换行不能取得有效的字符，现修改为如果关键字换行返回行坐标信息
            // 如果解析的坐标为空，证明按照字符取未取得关键字的坐标信息，此时返回行坐标信息
            if (textRender.isEmpty()) {
                textRender.add(renderInfo);
                // 已完成解析
                hasCompleted = true;
            }
            q = pdfStr.indexOf(keyWord, q+1);
            pdfStr.delete(0, pdfStr.length());
        }
    }

    /**
     * 判断是否提取到了关键字的坐标
     */
    public boolean hasCompleted() {

        return hasCompleted;
    }

    @Override
    public void beginTextBlock() {

    }

    @Override
    public void endTextBlock() {
        if (!getTextRender().isEmpty()) {
            setHasCompleted(true);
        }
    }

    @Override
    public void renderImage(ImageRenderInfo arg0) {

    }
}
